MacTech 1 to 12/MacTech-vol-1-12.toast/Source/MacTech® Magazine/Volume 03 - 1987/03.01 Jan 87/pascal source/myWriteStuff

Text File | 1986-11-21 | 20.3 KB | 835 lines | [TEXT/PJMM]

UNIT myWriteStuff;

INTERFACE

    USES
        ROM85, EditorGlobals, ScrollStuff;

    PROCEDURE UpdateMenus;
    PROCEDURE UpdateFonts;
    PROCEDURE UpdateSize;
    PROCEDURE UpdateStyle;
    PROCEDURE UpdateJust;
    PROCEDURE UpdateMode;
    PROCEDURE ShowFonts (FontNum : integer);
    PROCEDURE doCloseWindow (goodbyWindow : windowPtr);
    PROCEDURE doAbout;
    PROCEDURE doNewWindow;
    PROCEDURE doMenubar (menuResult : LongInt);
    PROCEDURE doContent (ConEvent : EventRecord;
                                    contentWindow : windowPtr);
    PROCEDURE doDrag (GrabWindow : WindowPtr;
                                    GlobalMouse : point);
    PROCEDURE doGrow (ResizeWindow : WindowPtr;
                                    Globalmouse : point;
                                    Zoomflg : Boolean);

IMPLEMENTATION

    PROCEDURE BashText;
        VAR
            FontIRec : FontInfo;
            Height : integer; {calculated new lineheight}
            CharPos : integer;
            ControlLine : integer;
    BEGIN
        SetPort(myWindows[currentWindow]);
        GetFontInfo(FontIRec); {from current grafport}
        myText[currentWindow]^^.txFont := thePort^.txFont;
        myText[currentWindow]^^.txFace := thePort^.txFace;
        myText[currentWindow]^^.txMode := thePort^.txMode;
        myText[currentWindow]^^.txSize := thePort^.txSize;
        myText[currentWindow]^^.fontAscent := FontIRec.ascent;
        Height := FontIRec.ascent + FontIRec.descent + FontIRec.leading;
        myText[currentWindow]^^.lineHeight := Height;
        myText[currentWindow]^^.just := LastJust;

        ControlLine := GetCtlValue(myHControls[currentWindow]);
        CharPos := myText[currentWindow]^^.lineStarts[ControlLine];
        TECalText(myText[currentWindow]);
        InvalRect(myText[currentWindow]^^.ViewRect);
        AdjustScrollBar(currentWindow);
        ScrollChar(currentWindow, CharPos, False); {reset scroller value}
        CheckInsertion(currentWindow);

    END;

    PROCEDURE doFonts (fontNo : integer);
        VAR
            FontNumber : integer;
            FontName : Str255;
    BEGIN
        IF currentWindow <> 0 THEN
            BEGIN
                getItem(myMenus[FontMenu], fontNo, FontName);
                GetFNum(FontName, FontNumber);
                SetPort(myWindows[currentWindow]);
                TextFont(FontNumber); {change port's font}
                UpdateFonts;    {update menu}
                BashText;    {update window}
            END;
    END;

    PROCEDURE doSize (sizeNo : integer);
        CONST
            DialogID = 129; {other dialog}
        VAR
            sizeNumber : LongInt;
            sizeNum : integer;
            sizeName : Str255;
            SizeCount : integer;
            dialogP : DialogPtr;
            item : integer;
            dtype : integer;
            ditem : handle;
            drect : rect;
            dtext : Str255;
            activeSize : integer;
            LongSize : LongInt;
            sizeStr : Str255;
    BEGIN
        IF currentWindow <> 0 THEN
            BEGIN
                SizeCount := (CountMItems(myMenus[SizeMenu])) - 2;
                IF (sizeNo <= SizeCount) AND (sizeNo > 0) THEN
                    BEGIN
                        GetItem(myMenus[SizeMenu], sizeNo, sizeName);
                        StringToNum(sizeName, sizeNumber);
                        sizeNum := LoWord(sizeNumber);
                        SetPort(myWindows[currentWindow]);
                        TextSize(sizeNum); {change port's text size}
                        UpdateSize;
                        BashText;
                    END; {of sizeno}

                IF sizeNo = SizeCount + 2 THEN
                    BEGIN    {do other}
                        activeSize := thePort^.txSize;
                        LongSize := LongInt(activeSize);
                        NumToString(LongSize, sizeStr);
                        ParamText(sizeStr, '', '', '');
                        dialogP := GetNewDialog(DialogID, NIL, pointer(-1));
                        ModalDialog(NIL, item);
                        GetDItem(dialogP, otherItem, dtype, ditem, drect);
                        GetIText(ditem, dtext);
                        StringToNum(dtext, LongSize);
                        sizeNum := LoWord(LongSize);
                        DisposDialog(dialogP);

                        IF (sizeNum > 0) AND (sizeNum < sizelimit) THEN
                            BEGIN
                                SetPort(myWindows[currentWindow]);
                                TextSize(sizeNum); {change port's text size}
                                UpdateSize;
                                BashText;
                            END
                        ELSE
                            sysbeep(5); {size too big}
                    END; {of other}
            END; {of currentWindow<>0}
    END;    {of proc}

    PROCEDURE doStyle (StyleNo : integer);
        VAR
            NewStyle : Style;

    BEGIN
        IF currentWindow <> 0 THEN
            BEGIN
                IF myWindows[currentWindow] = FrontWindow THEN
                    BEGIN
                        SetPort(myWindows[currentWindow]);
                        NewStyle := [];
                        CASE StyleNo OF
                            sLeft :
                                myText[currentWindow]^^.just := teJustLeft;
                            sCenter :
                                myText[currentWindow]^^.just := teJustCenter;
                            sRight :
                                myText[currentWindow]^^.just := teJustRight;
                            sPlain :
                                BEGIN
                                    textface([]);
                                END;
                            sBold :
                                BEGIN
                                    NewStyle := [bold];
                                END;
                            sItalic :
                                BEGIN
                                    NewStyle := [italic];
                                END;
                            sUnderline :
                                BEGIN
                                    NewStyle := [underline];
                                END;
                            sOutline :
                                BEGIN
                                    NewStyle := [outline];
                                END;
                            sShadow :
                                BEGIN
                                    NewStyle := [shadow];
                                END;
                            sCondense :
                                BEGIN
                                    NewStyle := [condense];
                                END;
                            sExtend :
                                BEGIN
                                    NewStyle := [extend];
                                END;
                            OTHERWISE
                                BEGIN
                                END;
                        END;  {of case}
                        IF NewStyle <= thePort^.txFace THEN
                            textface(thePort^.txFace - NewStyle)
                        ELSE
                            textface(thePort^.txFace + NewStyle);
                        UpdateJust;
                        UpdateStyle;
                        BashText;
                    END; {of currentWindow}
            END; {of frontwindow}
    END; {of proc}

    PROCEDURE doMode (ModeNo : integer);
    BEGIN
        IF currentWindow <> 0 THEN
            BEGIN
                SetPort(myWindows[currentWindow]);
                TextMode(ModeNo);
                UpdateMode;
                BashText;
            END;
    END;

    PROCEDURE UpdateMenus;
    BEGIN
        UpdateFonts;
        UpdateSize;
        UpdateStyle;
        UPdateJust;
        UpdateMode;
    END;

    PROCEDURE UpdateFonts;
        VAR
            i : integer;
            FontCount : integer;
            FontNumber : integer;
            activeFont : Str255;
            FontName : Str255;
    BEGIN
        GetFontName(thePort^.txFont, activeFont);
        FontCount := CountMItems(myMenus[FontMenu]);
        FOR i := 1 TO FontCount DO
            BEGIN
                GetItem(myMenus[FontMenu], i, FontName);
                IF (FontName = activeFont) THEN
                    BEGIN
                        CheckItem(myMenus[FontMenu], LastmFont, false);
                        CheckItem(myMenus[FontMenu], i, true);
                        LastmFont := i;
                        GetFNum(FontName, FontNumber);
                        LastFont := FontNumber;
                        ShowFonts(LastFont);
                    END;    {of if then}
            END;    {of i loop}
    END;

    PROCEDURE UpdateSize;
        VAR
            sizeCount : integer;
            sizeNumber : LongInt;
            sizeNum : integer;
            activeSize : integer;
            sizeName : Str255;
            i : integer;
            doneflg : boolean;
    BEGIN
        doneflg := false;
        activeSize := thePort^.txSize;
        SizeCount := (CountMItems(myMenus[SizeMenu])) - 2;
        FOR i := 1 TO SizeCount DO
            BEGIN
                GetItem(myMenus[SizeMenu], i, sizeName);
                StringToNum(sizeName, sizeNumber);
                sizeNum := LoWord(sizeNumber);
                IF (sizeNum = activeSize) THEN
                    BEGIN
                        CheckItem(myMenus[SizeMenu], LastmSize, false);
                        CheckItem(myMenus[SizeMenu], i, true);
                        LastmSize := i;
                        LastSize := sizeNum;
                        doneflg := true;
                    END;{of if then}
            END;    {of i loop}

        IF doneflg = false THEN
            BEGIN    {do other}
                IF (activeSize > 0) AND (activeSize < sizelimit) THEN
                    BEGIN
                        CheckItem(myMenus[SizeMenu], LastmSize, false);
                        CheckItem(myMenus[SizeMenu], SizeCount + 2, true);
                        LastmSize := SizeCount + 2;
                        LastSize := activeSize;
                    END;
            END;
    END; {of proc}

    PROCEDURE UpdateStyle;
        VAR
            i, j : integer;
            StyleCount : integer;
            activeStyle : Style;
            MenuStyle : Style;
    BEGIN
        StyleCount := (CountMItems(myMenus[StyleMenu]) - Style2Items);
        activeStyle := thePort^.txFace;
        FOR i := 1 TO StyleCount DO
            BEGIN
                CASE i OF
                    1 :
                        MenuStyle := [];
                    2 :
                        MenuStyle := [bold];
                    3 :
                        MenuStyle := [italic];
                    4 :
                        MenuStyle := [underline];
                    5 :
                        MenuStyle := [outline];
                    6 :
                        MenuStyle := [shadow];
                    7 :
                        MenuStyle := [condense];
                    8 :
                        MenuStyle := [extend];
                    OTHERWISE
                        MenuStyle := [];
                END;  {of case i}

                IF ((MenuStyle <= activeStyle) AND (MenuStyle <> [])) THEN
                    BEGIN
                        CheckItem(myMenus[StyleMenu], i, true);
                        CheckItem(myMenus[StyleMenu], 1, false);
                        LastmStyle := i;
                        LastStyle := activeStyle;
                    END
                ELSE IF activeStyle = [] THEN
                    BEGIN
                        CheckItem(myMenus[StyleMenu], 1, true);
                        FOR j := 2 TO StyleCount DO
                            BEGIN
                                CheckItem(myMenus[StyleMenu], j, false);
                            END; {of j loop}
                        LastmStyle := 1;
                        LastStyle := activeStyle;
                    END { of []}
                ELSE
                    BEGIN
                        CheckItem(myMenus[StyleMenu], i, false);
                    END;
            END;    {of i loop}
    END;

    PROCEDURE UpdateJust;
        VAR
            i : integer;
            activeJust : integer;
    BEGIN
        IF currentWindow <> 0 THEN
            BEGIN
                IF myWindows[currentWindow] = FrontWindow THEN
                    BEGIN
                        i := (CountMItems(myMenus[StyleMenu]) - Style2Items);
                        CASE LastJust OF
                            teJustLeft :
                                CheckItem(myMenus[StyleMenu], i + 2, false);
                            teJustCenter :
                                CheckItem(myMenus[StyleMenu], i + 3, false);
                            teJustRight :
                                CheckItem(myMenus[StyleMenu], i + 4, false);
                            OTHERWISE
                                BEGIN
                                END;
                        END;  {of case}

                        activeJust := myText[currentWindow]^^.just;
                        LastJust := activeJust;
                        CASE activeJust OF
                            teJustLeft :
                                BEGIN
                                    CheckItem(myMenus[StyleMenu], i + 2, true);
                                    LastmJust := i + 2;
                                END;
                            teJustCenter :
                                BEGIN
                                    CheckItem(myMenus[StyleMenu], i + 3, true);
                                    LastmJust := i + 3;
                                END;
                            teJustRight :
                                BEGIN
                                    CheckItem(myMenus[StyleMenu], i + 4, true);
                                    LastmJust := 1 + 4;
                                END;
                            OTHERWISE
                                BEGIN
                                END;
                        END; {of case}
                    END;
            END;
    END;

    PROCEDURE UpdateMode;
        VAR
            activeMode : integer;
    BEGIN
        activeMode := thePort^.txMode;
        CheckItem(myMenus[ModeMenu], LastmMode, false);
        CASE activeMode OF
            1 :
                BEGIN
                    CheckItem(myMenus[ModeMenu], 1, true);
                    LastmMode := 1;
                END;
            2 :
                BEGIN
                    CheckItem(myMenus[ModeMenu], 2, true);
                    LastmMode := 2;
                END;
            3 :
                BEGIN
                    CheckItem(myMenus[ModeMenu], 3, true);
                    LastmMode := 3;
                END;
            OTHERWISE
                BEGIN
                END;
        END; { of case}
        LastMode := activeMode;
    END;

    PROCEDURE ShowFonts; {(FontNum : integer);}
        VAR
            i : integer;
            sizeStr : Str255;
            sizeNum : LongInt;
    BEGIN
        FOR i := 1 TO (CountMItems(myMenus[sizeMenu]) - 2) DO
            BEGIN
                GetItem(myMenus[sizeMenu], i, sizeStr);
                StringToNum(sizeStr, sizeNum);
                IF RealFont(FontNum, sizeNum) THEN
                    SetItemStyle(myMenus[sizeMenu], i, [Outline])
                ELSE
                    SetItemStyle(myMenus[sizeMenu], i, []);
            END;    {of i}
    END;    {of proc}

    PROCEDURE doCloseWindow; {(goodbyWindow : windowPtr}
        VAR
            i : integer;
    BEGIN
        HideWindow(goodbyWindow);
        CurrentWindow := 0;
        FOR i := 1 TO MaxWindows DO
            BEGIN
                IF goodbyWindow = myWindows[i] THEN
                    BEGIN
                        goodbyList[i] := i;
                    END;
            END;
    END;

    PROCEDURE doAbout;
        CONST
            DialogID = 128;
        VAR
            dialogP : DialogPtr;
            item : integer;
    BEGIN
        dialogP := GetNewDialog(DialogID, NIL, pointer(-1));
        ModalDialog(NIL, item);
        DisposDialog(dialogP);
    END;

    PROCEDURE doNewWindow;
        VAR
            i : integer;
            doneflg : boolean;
    BEGIN
        doneflg := false;
        FOR i := 1 TO MaxWindows DO
            BEGIN
                IF doneflg = false THEN
                    BEGIN
                        IF goodbyList[i] = i THEN
                            BEGIN    {window is free}
                                CurrentWindow := i;
                                SetPort(myWindows[CurrentWindow]);
                                UpdateMenus;
                                goodbyList[i] := 0;
                                doneflg := true;

                                TESetSelect(0, MaxLines, myText[i]);
                                TEDelete(myText[i]);
                                ShowWindow(myWindows[i]);
                                SelectWindow(myWindows[i]);
                                AdjustScrollBar(i);
                                CheckInsertion(i);
                            END;    {of free window stuff}
                    END;     {of if doneflg}
            END;    {of for i loop}
        IF doneflg = false THEN
            sysBeep(5);    {no windows left}
    END;    {of proc}

    PROCEDURE doMenubar; {(menuResult : LongInt)}
        VAR
            theMenu : integer;
            theItem : integer;
            daName : STR255;
            accItem : integer;
            i : integer;
    BEGIN
        theMenu := HiWord(menuResult); {menu}
        theItem := LoWord(menuResult); {item}
        CASE theMenu OF
            AppleMenu :
                BEGIN
                    IF theItem = aAbout THEN
                        doAbout
                    ELSE
                        BEGIN
                            GetItem(myMenus[AppleMenu], theItem, daName);
                            accItem := OpenDeskAcc(daName);
                        END; {else}
                END; {of AppleMenu}
            FileMenu :
                BEGIN
                    CASE theItem OF
                        fNew :
                            BEGIN
                                doNewWindow;
                            END;
                        fOpen :
                            BEGIN
                            END;
                        fClose :
                            BEGIN
                                IF currentWindow <> 0 THEN
                                    IF myWindows[currentWindow] = FrontWindow THEN
                                        doCloseWindow(myWindows[currentWindow]);
                            END;
                        fSave :
                            BEGIN
                            END;
                        fSaveAs :
                            BEGIN
                            END;
                        fPageSet :
                            BEGIN
                            END;
                        fPrint :
                            BEGIN
                            END;
                        fQuit :
                            BEGIN
                                FOR i := 1 TO MaxWindows DO
                                    BEGIN
                                        DisposeControl(myVControls[i]);
                                        DisposeControl(myHControls[i]);
                                        TEDispose(myText[i]);
                                        DisposeWindow(myWindows[i]);
                                    END;
                                Finished := true;
                            END;
                        OTHERWISE
                            BEGIN
                            END;
                    END; {of theitem}
                END; {of FileMenu}
            EditMenu :
                BEGIN
                    IF NOT SystemEdit(theitem - 1) THEN
                        BEGIN
                            CASE theItem OF
                                eUndo :
                                    BEGIN
                                        sysbeep(5);
                                    END;
                                eCut :
                                    BEGIN
                                        IF currentWindow <> 0 THEN
                                            BEGIN
                                                CheckInsertion(currentWindow);
                                                TECut(myText[currentWindow]);
                                                AdjustScrollBar(currentWindow);
                                                CheckInsertion(currentWindow);
                                                dummy := ZeroScrap;
                                                dummy := TEToScrap;
                                            END
                                        ELSE
                                            sysbeep(5);
                                    END;
                                eCopy :
                                    BEGIN
                                        IF currentWindow <> 0 THEN
                                            BEGIN
                                                CheckInsertion(currentWindow);
                                                TECopy(myText[currentWindow]);
                                                dummy := ZeroScrap;
                                                dummy := TEToScrap;
                                            END
                                        ELSE
                                            sysbeep(5);
                                    END;
                                ePaste :
                                    BEGIN
                                        IF currentWindow <> 0 THEN
                                            BEGIN
                                                IF TEFromScrap <> noErr THEN
                                                    BEGIN    {Desk Scrap to TEScrap}
                                                    END;
                                                IF (myText[currentWindow]^^.teLength + TEGetScrapLen) > MaxInt THEN
                                                    SysBeep(5)
                                                ELSE
                                                    BEGIN
                                                        CheckInsertion(currentWindow);
                                                        TEPaste(myText[currentWindow]);
                                                        AdjustScrollBar(currentWindow);
                                                        CheckInsertion(currentWindow);
                                                    END; { of else}
                                            END
                                        ELSE
                                            sysbeep(5);
                                    END; { of paste}
                                eClear :
                                    BEGIN
                                        IF currentWindow <> 0 THEN
                                            BEGIN
                                                CheckInsertion(currentWindow);
                                                TEDelete(myText[currentWindow]);
                                                AdjustScrollBar(currentWindow);
                                                CheckInsertion(currentWindow);
                                            END
                                        ELSE
                                            sysbeep(5);
                                    END;
                                eSelAll :
                                    BEGIN
                                        IF currentWindow <> 0 THEN
                                            BEGIN
                                                TESetSelect(0, MaxLines, myText[currentWindow]);
                                                TECopy(myText[currentWindow]);
                                                dummy := ZeroScrap;
                                                dummy := TEToScrap;
                                            END
                                        ELSE
                                            sysbeep(5);
                                    END;
                                eClipboard :
                                    BEGIN
                                        currentWindow := 0;
                                        SetPort(ClipBdWindow);
                                        ShowWindow(ClipBdWindow);
                                        SelectWindow(ClipBdWindow);
                                        UpdateMenus;
                                    END;
                                OTHERWISE {no menu items selected}
                                    BEGIN
                                    END;
                            END; {of theItem}
                        END; {of if then}
                END; {of EditMenu}
            SearchMenu :
                BEGIN
                END;
            FormatMenu :
                BEGIN
                END;
            FontMenu :
                BEGIN
                    doFonts(theItem);
                END;
            SizeMenu :
                BEGIN
                    doSize(theItem);
                END;
            StyleMenu :
                BEGIN
                    doStyle(theItem);
                END;
            ModeMenu :
                BEGIN
                    doMode(theItem);
                END;
            TransferMenu :
                BEGIN
                END;
            OTHERWISE
                BEGIN
                END;
        END; {of theMenu}
        HiliteMenu(0);    {un-hilite selected menu}
    END;

    PROCEDURE doContent; {(ConEvent : EventRecord}
                                    {contentWindow : windowPtr);}
        VAR
            localPt, globalPt : Point;
            part : integer;
            control : ControlHandle;
            i : integer;
    BEGIN
        IF contentWindow <> FrontWindow THEN
            SelectWindow(contentWindow);
        globalPt := ConEvent.where;
        localPt := globalPt;        {global coord of mouse}
        GlobalToLocal(localPt);     {local coord of mouse}
        part := FindControl(localPt, contentWindow, control);

        IF contentWindow = ClipBdWindow THEN
            BEGIN
                currentWindow := 0;
                SetPort(ClipBdWindow);
                UpdateMenus;
            END
        ELSE
            BEGIN
                FOR i := 1 TO MaxWindows DO
                    IF contentWindow = myWindows[i] THEN
                        BEGIN
                            currentWindow := i;
                            SetPort(myWindows[currentWindow]);
                            UpdateMenus;
                        END;
            END;
        i := currentWindow;
        IF currentWindow <> 0 THEN
            BEGIN
                IF part <> 0 THEN
                    doScrollers(i, control, part, localpt);
                IF part = 0 THEN
                    BEGIN
                        IF PtInRect(localPt, myText[i]^^.viewRect) THEN
                            BEGIN
                                TEClick(localPt, BitAnd(ConEvent.modifiers, ShiftKey) = ShiftKey, myText[i])
                            END;  {of ptInRect}
                    END; { of part=0 }
            END; {of currentWindow <>0}
    END;  {of proc}

    PROCEDURE doDrag; {(GrabWindow : WindowPtr}
                                {GlobalMouse : point);}
        VAR
            i : integer;
    BEGIN
        IF GrabWindow <> FrontWindow THEN
            BEGIN
                SelectWindow(GrabWindow);
                IF GrabWindow = ClipBdWindow THEN
                    BEGIN
                        currentWindow := 0;
                        SetPort(ClipBdWindow);
                        UpdateMenus;
                    END
                ELSE
                    FOR i := 1 TO MaxWindows DO
                        IF GrabWindow = myWindows[i] THEN
                            BEGIN
                                currentWindow := i;
                                SetPort(myWindows[i]);
                                UpdateMenus;
                            END;
            END;
        DragWindow(GrabWindow, GlobalMouse, DragArea);
    END;

    PROCEDURE doGrow; {(ResizeWindow : WindowPtr;}
                                {Globalmouse : point;}
                                {ZoomFlg:Boolean);}
        VAR
            newSize : LongInt;
            hsize : integer;
            vsize : integer;
            oldPort : GrafPtr;
            saveRect : rect;
            textlines : integer;
            i : integer;
            windowLines : integer;
            CharPos : integer;
            ControlLine : integer;
            tempLong : LongInt;
    BEGIN
        IF (ResizeWindow <> FrontWindow) THEN
            SelectWindow(ResizeWindow)
        ELSE
            BEGIN
                IF (ZoomFlg) THEN
                    BEGIN
                        WITH ResizeWindow^.portRect DO
                            BEGIN
                                tempLong := bottom - top;
                                newSize := BitShift(tempLong, 16);
                                newSize := newSize + (right - left);
                            END;
                    END
                ELSE
                    newSize := GrowWindow(ResizeWindow, Globalmouse, GrowArea);
                IF newSize <> 0 THEN
                    BEGIN  {grow the window}
                        hsize := LoWord(newSize);
                        vsize := HiWord(newSize);
                        IF ResizeWindow = ClipBdWindow THEN
                            SizeWindow(ResizeWindow, hsize, vsize, true);
                        FOR i := 1 TO MaxWindows DO
                            BEGIN
                                IF ResizeWindow = myWindows[i] THEN
                                    BEGIN
                                        WITH ResizeWindow^.portRect DO {Pre-Grow}
                                            BEGIN
                                                SetRect(VCRect, right - (SBarWidth - 1), top - 1, right + 1, bottom - (SBarWidth - 2));
                                                SetRect(HCRect, left - 1, bottom - (SBarWidth - 1), right - (SBarWidth - 2), bottom + 1);
                                                SetRect(GrowRect, HCRect.right, HCRect.top, VCRect.right, HCRect.bottom);
                                            END;  {of with }
                                        SizeWindow(ResizeWindow, hsize, vsize, TRUE); {new portRect}
                                        InvalRect(GrowRect); {Pesky grow icon!!}
                                        EraseRect(GrowRect);  {looks better if done after sizewind}
                                        WITH ResizeWindow^.portRect DO {Post Grow}
                                            BEGIN
                                                SetRect(VCRect, right - (SBarWidth - 1), top - 1, right + 1, bottom - (SBarWidth - 2));
                                                SetRect(HCRect, left - 1, bottom - (SBarWidth - 1), right - (SBarWidth - 2), bottom + 1);
                                                SetRect(GrowRect, HCRect.right, HCRect.top, VCRect.right, HCRect.bottom);
                                                SetRect(ViewRect, left + 4, top + 4, right - (SBarWidth - 1), bottom - (SBarWidth - 1));
                                            END;  {of with }
                                        DestRect := ViewRect;

                                        InvalRect(GrowRect);  {needed for update on shrink}
                                        HideControl(myVControls[i]);
                                        HIdeControl(myHControls[i]);
                                        MoveControl(myVControls[i], VCRect.left, VCRect.top);
                                        MoveControl(myHControls[i], HCRect.left, HCRect.top);
                                        SizeControl(myVControls[i], SBarWidth, VCRect.bottom - VCRect.top);
                                        SizeControl(myHControls[i], HCRect.right - HCRect.left, SBarWidth);
                                        ShowControl(myVControls[i]);
                                        ShowControl(myHControls[i]);
                                        Validrect(HCRect);
                                        ValidRect(VCRect);

                    {Update TextEdit Display}
                                        myText[i]^^.ViewRect := ViewRect;
                                        myText[i]^^.DestRect := DestRect;
                                        currentWindow := i;
                                        BashText;

                                    END; {of if ResizeWindow}
                            END;  {of i =1 to MaxWindows}
                    END; {of else grow window stuff}
            END; {of if then newsize}
    END;  { of proc }

END. {of unit}